Lambda the Ultimate

I really don't want to start a LtU thread consisting of rants (or raves) about dynamic languages. This subject was discussed here more than a few times, and I am not aware of any new arguments that weren't discussed here before. Still, I think the recent brouhaha over statements from Gosling shoud be part of the historical record that is the LtU archive. And there's even a small chance some LtU readers haven't heard of this incident yet.

A sixteen-hour lecture course aimed at final-year computer science undergraduates and MSc students.

The course notes are detailed and include things like call-by-value LC, Boehm Theorem, and several interesting mini-projects for students.

Jeremy Gibbons (2006). Design Patterns as Higher-Order Datatype-Generic Programs. Submitted for publication.

Design patterns are reusable abstractions in object-oriented software. However, using current programming languages, these elements can only be expressed extra-linguistically: as prose, pictures, and prototypes. We believe that this is not inherent in the patterns themselves, but evidence of a lack of expressivity in the languages of today. We expect that, in the languages of the future, design patterns will be expressible as reusable library code. Indeed, we claim that the languages of tomorrow will suffice; the future is not far away. The necessary features are higher-order and datatype-generic constructs; these features are already or nearly available now. We argue the case by presenting higher-order datatype-generic programs capturing ORIGAMI, a small pattern language of recursive data structures.

Last time this research was mentioned there were some concerns about the idea of executable patterns. Obviously, this approach is related to many older discussions about mining patterns for language features, frameworks as opposed to patterns and so on.

Hopefully, now that things are more explicit, we will be able to have a more in depth discussion.

We seem to be in denial that our industry is maturing, we are losing our elders, some of us don’t code any more and many of our new things are really good ideas from 20 or more years ago. Some good old ideas reappear because the technology is now available to commercially exploit them; others become popular because they provide a better approach to solving a particular problem. Reinvention and improvement of good old ideas is both scholarly and sound engineering provided the prior art is cited and explained as opposed to hyped or even patented. This means we need to look for the important small improvements and not just the big bang!

Nothing remarkably new in this article, but you might want to take a look. The article was inspired by The Next Move in Programming: A Conversation with Sun's Victoria Livschitz. Victoria Livschitz's ideas were discussed here in the past.

Steve Ross-Talbot has more than 20 years of experience leveraging cutting-edge research and applying it to real business problems. Recently he founded Pi4 Technologies where he and his team draw on the field of the pi-calculus to improve the ability to design, automate, and analyze business processes.

The interview goes into more detail than you might expect,

Surely, we should be able to prove something about interaction. I started looking at other papers that leveraged the work of Robin Milner and the pi-calculus and found some fundamental work by Vasco Vasconcelos and Kohei Honda. Their work looked at something called session type...

There's a discussion on Artima about domain-specific language development. Actually, there isn't too much discussion (yet), but there's a link to this ACM Computing Survey article (PDF), which looks quite good. It has a survey of DSL use cases, implementation techniques, etc., and explores some reasons to choose whether to implement a new DSL.

Via the plt-scheme mailing list:

We are pleased to announce the first public release [beta 7] of ACL2
in DrScheme, a combination of the ACL2 theorem prover system with the
DrScheme programming environment. The objective of this project is
to provide a development environment for ACL2 suitable for novice
users as well as enhancements of ACL2 that are attractive for the
typical undergraduate student (graphics, interactive games, sound).

There's a tutorial with screenshots and some examples on the ACL2 in DrScheme web page.

I'm always happy to see reasoning about programs introduced at the undergraduate level. I wonder what the LtU community would do with a tool like this. What cool things would you teach with a beginner's theorem prover?

This announcement has been made in various places, including comp.lang.scheme:

March 7, 2006

Since the last report of the Steering Committee, a number of important changes have taken place.

First, Marc Feeley and Manuel Serrano have resigned from the Editors Committee. We have accepted their resignations with regret, and with gratitude for the efforts they have expended to produce a revised Scheme standard.

In light of these changes, the Steering Committee has amended the Charter to:

(a) change the number of Editors from seven to five.

(b) replace the office of Editor-in-Chief by a Chair and a Project Editor. The Chair is responsible for organizing meetings and other activities and ensuring that the process makes progress in an orderly fashion. The Project Editor is responsible for producing standardization documents.

The five editors have chosen their Chair and Project Editor. They are:

Chair: Kent Dybvig
Project Editor: Mike Sperber

The Editors Committee has now produced a progress report, which is available at schemers.org. In it they state their intention to deliver to the Steering Committee a complete draft R6RS by September 1, 2006.

The Steering Committee looks forward to receiving their draft.

Alternate links to the Editors' Progress Report:

http://www.cs.indiana.edu/~dyb/r6rs/status.pdf
http://www.cs.indiana.edu/~dyb/r6rs/status.html

---The Scheme Language Steering Committee:
Alan Bawden
Guy Steele
Mitch Wand

Active Libraries and Universal Languages

The ideas in this dissertation had their early origins in the years I spent working on the Blitz++
library for numerical arrays. Rather than relying on the compiler to optimize arrays, it performed
these optimizations itself using template techniques (‘expression templates’ and ‘template metaprograms’).
The fact this could be done made me wonder about the general problem of domainspecific
code optimization. From reading the literature it seemed a widespread debate: where ought
domain-specific optimizations be performed? In compilers? Compiler plug-ins? Metalevel code?
Preprocessors? Libraries? The C++ experience indicates that with a sufficiently powerful language
and compiler, libraries can define their own optimizations, and we can package abstractions and
optimizations together as a coherent library. Template metaprogramming is, let’s be frank, a rather
miserable programming environment — its popularity suggests a real need in this area. The definition
of Active Libraries helped turn these vague thoughts into a concrete goal: to realize
compilers and languages to support such libraries in earnest.
This dissertation proposes one possible direction for this.

Or, shorter:

Roughly speaking, this thesis addresses the question: How might we provide DSLs that are fast
and safe?